//		-------------------------------
//		Copyright (c) Corman Technologies Inc.
//		See LICENSE.txt for license information.
//		-------------------------------
//
//		File:		CommonLispFuncs.cpp
//		Contents:	Corman Lisp application source file
//		History:	1/28/99  RGC  Created.
//

#include <string.h>
#include <stdlib.h>

#include "CommonLispFuncs.h"

LambdaListString lambdaLists[] =
{
	// Evaluation and Compilation
	"COMPILE",					"COMPILE fname &optional function [Function]",
	"COMPILER-MACRO-FUNCTION",	"COMPILER-MACRO-FUNCTION fname &optional environment [Function]",
	"CONSTANTP",				"CONSTANTP expression &optional environment [Function]",
	"DECLAIM",					"DECLAIM declaration-spec [Macro]",
	"DECLARE",					"DECLARE declaration-spec*",
	"DEFINE-COMPILER-MACRO",	"DEFINE-COMPILER-MACRO fname parameters . body [Macro]",
	"DEFINE-SYMBOL-MACRO",		"DEFINE-SYMBOL-MACRO symbol expression [Macro]",
	"DEFMACRO",					"DEFMACRO symbol parameters . body [Macro]",
	"EVAL",						"EVAL expression [Function]",
	"EVAL-WHEN",				"EVAL-WHEN (case*) expression* [Special Operator]",
	"LAMBDA",					"LAMBDA parameters . body [Macro]",
	"LOAD-TIME-VALUE",			"LOAD-TIME-VALUE expression &optional constant [Special Operator]",
	"LOCALLY",					"LOCALLY declaration* expression* [Special Operator]",
	"MACROEXPAND",				"MACROEXPAND expression &optional environment [Function]",
	"MACROEXPAND-1",			"MACROEXPAND-1 expression &optional environment [Function]",
	"MACRO-FUNCTION",			"MACRO-FUNCTION symbol &optional environment [Function]",
	"PROCLAIM",					"PROCLAIM declaration-spec [Function]",
	"SPECIAL-OPERATOR-P",		"SPECIAL-OPERATOR-P symbol [Function]",
	"SYMBOL-MACROLET",			"SYMBOL-MACROLET ((symbol expression)*) declaration* expression* [Special Operator]",
	"THE",						"THE type expression [Special Operator]",
	"QUOTE",					"QUOTE object [Special Operator]",

	// Types and Classes
	"COERCE",					"COERCE object type [Function]",
	"DEFTYPE",					"DEFTYPE name parameters . body [Macro]",
	"SUBTYPEP",					"SUBTYPEP type1 type2 &optional environment [Function]",
	"TYPE-ERROR-DATUM",			"TYPE-ERROR-DATUM condition [Function]",
	"TYPE-ERROR-EXPECTED-TYPE",	"TYPE-ERROR-EXPECTED-TYPE condition [Function]",
	"TYPE-OF",					"TYPE-OF object [Function]",
	"TYPEP",					"TYPEP object type &optional environment [Function]",

	// Control and Data Flow
	"AND",						"AND expression* [Macro]",
	"APPLY",					"APPLY function &rest args [Function]",
	"BLOCK",					"BLOCK symbol expression* [Special Operator]",
	"CASE",						"CASE object (key expression*)* [({t | otherwise} expression*)] [Macro]",
	"CATCH",					"CATCH tag expression* [Special Operator]",
	"CCASE",					"CCASE object (key expression*)* [Macro]",
	"COMPILED-FUNCTION-P",		"COMPILED-FUNCTION-P object [Function]",
	"COMPLEMENT",				"COMPLEMENT predicate [Function]",
	"COND",						"COND ((test expression*)*) [Macro]",
	"CONSTANTLY",				"CONSTANTLY object [Function]",
	"CTYPECASE",				"CTYPECASE object (type expression*)* [Macro]",
	"DEFCONSTANT",				"DEFCONSTANT symbol expression [string] [Macro]",
	"DEFINE-MODIFY-MACRO",		"DEFINE-MODIFY-MACRO name parameters symbol [string] [Macro]",
	"DEFINE-SETF-EXPANDER",		"DEFINE-SETF-EXPANDER reader parameters . body [Macro]",
	"DEFPARAMETER",				"DEFPARAMETER symbol expression [string] [Macro]",
//	"DEFSETF",					"DEFSETF reader writer [string] [Macro]",
	"DEFSETF",					"DEFSETF reader parameters (var*) . body [Macro]",
	"DEFUN",					"DEFUN fname parameters . body [Macro]",
	"DEFVAR",					"DEFVAR symbol [expression [string]] [Macro]",
	"DESTRUCTURING-BIND",		"DESTRUCTURING-BIND	variables tree declaration* expression* [Macro]",
	"ECASE",					"ECASE object (key expression*)* [Macro]",
	"EQ",						"EQ object1 object2 [Function]",
	"EQL",						"EQL object1 object2 [Function]",
	"EQUAL",					"EQUAL object1 object2 [Function]",
	"EQUALP",					"EQUALP object1 object2 [Function]",
	"ETYPECASE",				"ETYPECASE object (key expression*)* [Macro]",
	"EVERY",					"EVERY predicate proseq &rest proseqs [Function]",
	"FBOUNDP",					"FBOUNDP fname [Function]",
	"FDEFINITION",				"FDEFINITION fname [Function]",
	"FLET",						"FLET ((fname parameters . body)*) declaration* expression* [Special Operator]",
	"FMAKUNBOUND",				"FMAKUNBOUND fname [Function]",
	"FUNCALL",					"FUNCALL function &rest args [Function]",
	"FUNCTION",					"FUNCTION name [Special Operator]",
	"FUNCTION-LAMBDA-EXPRESSION","FUNCTION-LAMBDA-EXPRESSION function [Function]",
	"FUNCTIONP",				"FUNCTIONP object [Function]",
	"LABELS",					"LABELS ((fname parameters . body)*) declaration* expression* [Special Operator]",
	"GET-SETF-EXPANSION",		"GET-SETF-EXPANSION place &optional environment [Function]",
	"GO",						"GO tag [Special Operator]",
	"IDENTITY",					"IDENTITY object [Function]",
	"IF",						"IF test then [else] [Special Operator]",
	"LET",						"LET ({symbol | (symbol [value])}*) declaration* expression* [Special Operator]",
	"LET*",						"LET* ({symbol | (symbol [value])}*) declaration* expression* [Special Operator]",
	"MACROLET",					"MACROLET ((symbol parameters . body)*) declaration* expression* [Special Operator]",
	"MULTIPLE-VALUE-BIND",		"MULTIPLE-VALUE-BIND (symbol*) expression1 declaration* expression* [Macro]",
	"MULTIPLE-VALUE-CALL",		"MULTIPLE-VALUE-CALL function expression* [Special Operator]",
	"MULTIPLE-VALUE-LIST",		"MULTIPLE-VALUE-LIST expression [Macro]",
	"MULTIPLE-VALUE-PROG1",		"MULTIPLE-VALUE-PROG1 expression1 expression* [Special Operator]",
	"MULTIPLE-VALUE-SETQ",		"MULTIPLE-VALUE-SETQ (symbol*) expression [Macro]",
	"NOT",						"NOT object [Function]",
	"NOTANY",					"NOTANY predicate proseq &rest proseqs [Function]",
	"NOTEVERY",					"NOTEVERY predicate proseq &rest proseqs [Function]",
	"NTH-VALUE",				"NTH-VALUE n expression [Macro]",
	"OR",						"OR expression* [Macro]",
	"PROG",						"PROG ({symbol | (symbol [value]}*) declaration* {tag | expression}* [Macro]",
	"PROG*",					"PROG* ({symbol | (symbol [value]}*) declaration* {tag | expression}* [Macro]",
	"PROG1",					"PROG1 expression1 expression* [Macro]",
	"PROG2",					"PROG2 expression1 expression2 expression* [Macro]",
	"PROGN",					"PROGN expression* [Special Operator]",
	"PROGV",					"PROGV symbols values expression* [Special Operator]",
	"PSETF",					"PSETF {place value}* [Macro]",
	"PSETQ",					"PSETQ {symbol value}* [Macro]",
	"RETURN",					"RETURN expression [Macro]",
	"RETURN-FROM",				"RETURN-FROM symbol expression [Special Operator]",
	"ROTATEF",					"ROTATEF place* [Macro]",
	"SETF",						"SETF {place value}* [Macro]",
	"SETQ",						"SETQ {symbol value}* [Special Operator]",
	"SHIFTF",					"SHIFTF place1 place* expression [Macro]",
	"SOME",						"SOME predicate proseq &rest proseqs [Function]",
	"TAGBODY",					"TAGBODY {tag | expression}* [Special Operator]",
	"THROW",					"THROW tag expression [Special Operator]",
	"TYPECASE",					"TYPECASE object (type expression*)* [({t | otherwise} expression*)] [Macro]",
	"UNLESS",					"UNLESS test expression* [Macro]",
	"UNWIND-PROTECT",			"UNWIND-PROTECT expression1 expression* [Special Operator]",
	"VALUES",					"VALUES &rest objects [Function]",
	"VALUES-LIST",				"VALUES-LIST prolist [Function]",
	"WHEN",						"WHEN test expression* [Macro]",

	// Iteration
	"DO",						"DO ({var | (var [init [update]])}*) (test result*) declaration* {tag | expression}* [Macro]",
	"DO*",						"DO* ({var | (var [init [update]])}*) (test result*) declaration* {tag | expression}* [Macro]",
	"DOLIST",					"DOLIST (var list [result]) declaration* {tag | expression}* [Macro]",
	"DOTIMES",					"DOTIMES (var integer [result]) declaration* {tag | expression}* [Macro]",
	"LOOP",						"LOOP [name-clause] var-clause* body-clause* [Macro]",
	"LOOP-FINISH",				"LOOP-FINISH [Macro]",

	// Objects
	"ADD-METHOD",				"ADD-METHOD generic-function method [Generic Function]",
	"ALLOCATE-INSTANCE",		"ALLOCATE-INSTANCE class &rest initargs &key [Generic Function]",
	"CALL-METHOD",				"CALL-METHOD method &optional next-methods [Macro]",
	"CALL-NEXT-METHOD",			"CALL-NEXT-METHOD &rest args [Function]",
	"CHANGE-CLASS",				"CHANGE-CLASS instance class &rest initargs &key [Generic Function]",
	"CLASS-NAME",				"CLASS-NAME class [Generic Function]",
	"CLASS-OF",					"CLASS-OF object [Function]",
	"COMPUTE-APPLICABLE-METHODS","COMPUTE-APPLICABLE-METHODS generic-function args [Generic Function]",
	"DEFCLASS",					"DEFCLASS name (superclass*) (slot-spec*) class-spec* [Macro]",
	"DEFGENERIC",				"DEFGENERIC fname parameters entry* [Macro]",
	"DEFINE-METHOD-COMBINATION","DEFINE-METHOD-COMBINATION symbol property* [Macro]",  // short form
//	"DEFINE-METHOD-COMBINATION","DEFINE-METHOD-COMBINATION symbol parameters (group-spec*) [(:arguments . parameters2)] [(:generic-function var)] . body [Macro]",  // long form
	"DEFMETHOD",				"DEFMETHOD fname qualifier* parameters . body [Macro]",
	"ENSURE-GENERIC-FUNCTION",  "ENSURE-GENERIC-FUNCTION fname &key argument-precedence-order declare documentation environment generic-function-class lambda-list method-class method-combination [Function]",
	"FIND-CLASS",				"FIND-CLASS symbol &optional error environment [Function]",
	"FIND-METHOD",				"FIND-METHOD generic-function qualifiers specializers &optional error [Generic Function]",
	"FUNCTION-KEYWORDS",		"FUNCTION-KEYWORDS method [Generic Function]",
	"INITIALIZE-INSTANCE",		"INITIALIZE-INSTANCE instance &rest initargs &key [Generic Function]",
	"MAKE-INSTANCE",			"MAKE-INSTANCE class &rest initargs &key [Generic Function]",
	"MAKE-INSTANCE-OBSOLETE",	"MAKE-INSTANCE-OBSOLETE class [Generic Function]",
	"MAKE-LOAD-FORM",			"MAKE-LOAD-FORM object &optional environment [Generic Function]",
	"MAKE-LOAD-FORM-SAVING-SLOTS","MAKE-LOAD-FORM-SAVING-SLOTS instance &key slot-names environment [Function]",
	"METHOD-QUALIFIERS",		"METHOD-QUALIFIERS method [Generic Function]",
	"NEXT-METHOD-P",			"NEXT-METHOD-P [Function]",
	"NO-APPLICABLE-METHOD",		"NO-APPLICABLE-METHOD generic-function &rest args [Generic Function]",
	"NO-NEXT-METHOD",			"NO-NEXT-METHOD generic-function method &rest args [Generic Function]",
	"REINITIALIZE-INSTANCE",	"REINITIALIZE-INSTANCE instance &rest initargs [Generic Function]",
	"REMOVE-MOTHOD",			"REMOVE-METHOD <generic-function> method [Generic Function]",
	"SHARED-INITIALIZE",		"SHARED-INITIALIZE instance names &rest initargs &key [Generic Function]",
	"SLOT-BOUNDP",				"SLOT-BOUNDP instance symbol [Function]",
	"SLOT-EXISTS-P",			"SLOT-EXISTS-P object symbol [Function]",
	"SLOT-MAKUNBOUND",			"SLOT-MAKUNBOUND <instance> symbol [Function]",
	"SLOT-MISSING",				"SLOT-MISSING class object symbol opname &optional value [Generic Function]",
	"SLOT-UNBOUND",				"SLOT-UNBOUND class instance symbol [Generic Function]",
	"SLOT-VALUE",				"SLOT-VALUE instance symbol [Function]",
	"WITH-ACCESSORS",			"WITH-ACCESSORS ((var fname)*) instance declaration* expression* [Macro]",
	"WITH-SLOTS",				"WITH-SLOTS ({symbol | (var symbol)}*) instance declaration* expression* [Macro]",
	"UNBOUND-SLOT-INSTANCE",	"UNBOUND-SLOT-INSTANCE condition [Function]",
	"UPDATE-INSTANCE-FOR-DIFFERENT-CLASS","UPDATE-INSTANCE-FOR-DIFFERENT-CLASS old new &rest initargs &key [Generic Function]",
	"UPDATE-INSTANCE-FOR-REDEFINED-CLASS","UPDATE-INSTANCE-FOR-REDEFINED-CLASS instance added deleted plist &rest initargs [Generic Function]",
	
	// Structures
	"COPY-STRUCTURE",			"COPY-STRUCTURE structure [Function]",
	"DEFSTRUCT",				"DEFSTRUCT {symbol | (symbol property*)} [string] field* [Macro]",
	
	// Conditions
	"ABORT",					"ABORT &optional condition [Function]",
	"ASSERT",					"ASSERT test [(place*) [cond arg*]] [Macro]",
	"BREAK",					"BREAK &rest args [Function]",
	"CELL-ERROR-NAME",			"CELL-ERROR-NAME condition [Function]",
	"CERROR",					"CERROR format cond &rest args [Function]",
	"CHECK-TYPE",				"CHECK-TYPE place type [string] [Macro]",
	"COMPUTE-RESTARTS",			"COMPUTE-RESTARTS &optional condition [Function]",
	"CONTINUE",					"CONTINUE &optional condition [Function]",
	"DEFINE-CONDITION",			"DEFINE-CONDITION name (parent*) (slot-spec*) class-spec* [Macro]",
	"ERROR",					"ERROR cond &rest args [Function]",
	"FIND-RESTART",				"FIND-RESTART r &optional condition [Function]",
	"HANDLER-BIND",				"HANDLER-BIND ((type handler)*) expression* [Macro]",
	"HANDLER-CASE",				"HANDLER-CASE test (type ([var]) declaration* expression* [(:no-error parameters declaration* expression*)] [Macro]",
	"IGNORE-ERRORS",			"IGNORE-ERRORS expression* [Macro]",
	"INVALID-METHOD-ERROR",		"INVALID-METHOD-ERROR method format &rest args [Function]",
	"INVOKE-DEBUGGER",			"INVOKE-DEBUGGER condition [Function]",
	"INVOKE-RESTART",			"INVOKE-RESTART restart &rest args [Function]",
	"INVOKE-RESTART-INTERACTIVELY","INVOKE-RESTART-INTERACTIVELY restart [Function]",
	"MAKE-CONDITION",			"MAKE-CONDITION type &rest args [Function]",
	"METHOD-COMBINATION-ERROR", "METHOD-COMBINATION-ERROR format &rest args [Function]",
	"MUFFLE-WARNING",			"MUFFLE-WARNING &optional condition [Function]",
	"RESTART-BIND",				"RESTART-BIND ((symbol function {key val}*)*) expression* [Macro]",
	"RESTART-CASE",				"RESTART-CASE test (symbol parameters {key val}* declaration* expression*) [Macro]",
	"RESTART-NAME",				"RESTART-NAME restart [Function]",
	"SIGNAL",					"SIGNAL cond &rest args [Function]",
	"SIMPLE-CONDITION-FORMAT-ARGUMENTS","SIMPLE-CONDITION-FORMAT-ARGUMENTS condition [Function]",
	"SIMPLE-CONDITION-FORMAT-CONTROL","SIMPLE-CONDITION-FORMAT-CONTROL condition [Function]",
	"STORE-VALUE",				"STORE-VALUE object &optional condition [Function]",
	"USE-VALUE",				"USE-VALUE object &optional condition [Function]",
	"WARN",						"WARN cond &rest args [Function]",
	"WITH-CONDITION-RESTARTS",	"WITH-CONDITION-RESTARTS condition restarts expression* [Macro]",
	"WITH-SIMPLE-RESTART",		"WITH-SIMPLE-RESTART (symbol format arg*) expression* [Macro]",
	
	// Symbols
	"BOUNDP",					"BOUNDP symbol [Function]",
	"COPY-SYMBOL",				"COPY-SYMBOL symbol &optional props-too [Function]",
	"GENSYM",					"GENSYM &optional prefix [Function]",
	"GENTEMP",					"GENTEMP &optional (prefix ""T"") package [Function]",
	"GET",						"GET symbol key &optional default [Function]",
	"KEYWORDP",					"KEYWORDP object [Function]",
	"MAKE-SYMBOL",				"MAKE-SYMBOL string [Function]",
	"MAKUNBOUND",				"MAKUNBOUND symbol [Function]",
	"SET",						"SET symbol object [Function]",
	"SYMBOL-FUNCTION",			"SYMBOL-FUNCTION symbol [Function]",
	"SYMBOL-NAME",				"SYMBOL-NAME symbol [Function]",
	"SYMBOLP",					"SYMBOLP object [Function]",
	"SYMBOL-PACKAGE",			"SYMBOL-PACKAGE symbol [Function]",
	"SYMBOL-PLIST",				"SYMBOL-PLIST symbol [Function]",
	"SYMBOL-VALUE",				"SYMBOL-VALUE symbol [Function]",
	"REMPROP",					"REMPROP <symbol> key [Function]",

	// Packages
	"DEFPACKAGE",				"DEFPACKAGE name property* [Macro]",
	"DELETE-PACKAGE",			"DELETE-PACKAGE package [Function]",
	"DO-ALL-SYMBOLS",			"DO-ALL-SYMBOLS (var [result]) declaration* {tag | expression}* [Macro]",
	"DO-EXTERNAL-SYMBOLS",		"DO-EXTERNAL-SYMBOLS (var [package [result]]) declaration* {tag | expression}* [Macro]",
	"DO-SYMBOLS",				"DO-SYMBOLS (var [package [result]]) declaration* {tag | expression}* [Macro]",
	"EXPORT",					"EXPORT symbols &optional package [Function]",
	"FIND-ALL-SYMBOLS",			"FIND-ALL-SYMBOLS name [Function]",
	"FIND-PACKAGE",				"FIND-PACKAGE package [Function]",
	"FIND-SYMBOL",				"FIND-SYMBOL string &optional package [Function]",
	"IMPORT",					"IMPORT symbols &optional package [Function]",
	"IN-PACKAGE",				"IN-PACKAGE name [Macro]",
	"INTERN",					"INTERN string &optional package [Function]",
	"LIST-ALL-PACKAGES",		"LIST-ALL-PACKAGES [Function]",
	"MAKE-PACKAGE",				"MAKE-PACKAGE name &key nicknames use [Function]",
	"PACKAGE-ERROR-PACKAGE",	"PACKAGE-ERROR-PACKAGE condition [Function]",
	"PACKAGE-NAME",				"PACKAGE-NAME package [Function]",
	"PACKAGE-NICKNAMES",		"PACKAGE-NICKNAMES package [Function]",
	"PACKAGEP",					"PACKAGEP object [Function]",
	"PACKAGE-SHADOWING-SYMBOLS","PACKAGE-SHADOWING-SYMBOLS package [Function]",
	"PACKAGE-USED-BY-LIST",		"PACKAGE-USED-BY-LIST package [Function]",
	"PACKAGE-USE-LIST",			"PACKAGE-USE-LIST package [Function]",
	"RENAME-PACKAGE",			"RENAME-PACKAGE <package> name &optional nicknames [Function]",
	"SHADOW",					"SHADOW names &optional package [Function]",
	"SHADOWING-IMPORT",			"SHADOWING-IMPORT symbols &optional package [Function]",
	"UNEXPORT",					"UNEXPORT symbols &optional package [Function]",
	"UNINTERN",					"UNINTERN symbol &optional package [Function]",
	"UNUSE-PACKAGE",			"UNUSE-PACKAGE packages &optional package [Function]",
	"USE-PACKAGE",				"USE-PACKAGE packages &optional package [Function]",
	"WITH-PACKAGE-ITERATOR",	"WITH-PACKAGE-ITERATOR (symbol packages key*) declaration* expression* [Macro]",

	// Numbers
	"ABS",						"ABS n [Function]",
	"ACOS",						"ACOS n [Function]",
	"ACOSH",					"ACOSH n [Function]",
	"ARITHMETIC-ERROR-OPERANDS","ARITHMETIC-ERROR-OPERANDS condition [Function]",
	"ARITHMETIC-ERROR-OPERATION","ARITHMETIC-ERROR-OPERATION condition [Function]",
	"ASH",						"ASH i pos [Function]",
	"ASIN",						"ASIN n [Function]",
	"ASINH",					"ASINH n [Function]",
	"ATAN",						"ATAN n1 &optional (n2 1) [Function]",
	"ATANH",					"ATANH n [Function]",
	"BOOLE",					"BOOLE op i1 i2 [Function]",
	"BYTE",						"BYTE length pos [Function]",
	"BYTE-POSITION",			"BYTE-POSITION spec [Function]",
	"BYTE-SIZE",				"BYTE-SIZE spec [Function]",
	"CEILING",					"CEILING r &optional (d 1) [Function]",
	"CIS",						"CIS r [Function]",
	"COMPLEX",					"COMPLEX r1 &optional r2 [Function]",
	"COMPLEXP",					"COMPLEXP object [Function]",
	"CONJUGATE",				"CONJUGATE n [Function]",
	"COS",						"COS n [Function]",
	"COSH",						"COSH n [Function]",
	"DECF",						"DECF place [n] [Macro]",
	"DECODE-FLOAT",				"DECODE-FLOAT f [Function]",
	"DENOMINATOR",				"DENOMINATOR rational [Function]",
	"DEPOSIT-FIELD",			"DEPOSIT-FIELD new spec i [Function]",
	"DPB",						"DPB new spec i [Function]",
	"EVENP",					"EVENP i [Function]",
	"EXP",						"EXP n [Function]",
	"EXPT",						"EXPT n1 n2 [Function]",
	"FCEILING",					"FCEILING r &optional (d 1) [Function]",
	"FFLOOR",					"FFLOOR r &optional (d 1) [Function]",
	"FLOAT",					"FLOAT n &optional f [Function]",
	"FLOAT-DIGITS",				"FLOAT-DIGITS f [Function]",
	"FLOATP",					"FLOATP object [Function]",
	"FLOAT-PRECISION",			"FLOAT-PRECISION f [Function]",
	"FLOAT-RADIX",				"FLOAT-RADIX f [Function]",
	"FLOAT-SIGN",				"FLOAT-SIGN f1 &optional (f2 (float 1 f1)) [Function]",
	"FLOOR",					"FLOOR r &optional (d 1) [Function]",
	"FROUND",					"FROUND r &optional (d 1) [Function]",
	"FTRUNCATE",				"FTRUNCATE r &optional (d 1) [Function]",
	"GCD",						"GCD &rest is [Function]",
	"IMAGPART",					"IMAGPART n [Function]",
	"INCF",						"INCF place [n] [Macro]",
	"INTEGER-DECODE-FLOAT",		"INTEGER-DECODE-FLOAT f [Function]",
	"INTEGER-LENGTH",			"INTEGER-LENGTH i [Function]",
	"INTEGERP",					"INTEGERP object [Function]",
	"ISQRT",					"ISQRT i [Function]",
	"LCM",						"LCM &rest is [Function]",
	"LDB",						"LDB spec i [Function]",
	"LDB-TEST",					"LDB-TEST spec i [Function]",
	"LOG",						"LOG n1 &optional n2 [Function]",
	"LOGAND",					"LOGAND &rest is [Function]",
	"LOGANDC1",					"LOGANDC1 i1 i2 [Function]",
	"LOGANDC2",					"LOGANDC2 i1 i2 [Function]",
	"LOGBITP",					"LOGBITP pos i [Function]",
	"LOGCOUNT",					"LOGCOUNT i [Function]",
	"LOGEQV",					"LOGEQV &rest is [Function]",
	"LOGIOR",					"LOGIOR &rest is [Function]",
	"LOGNAND",					"LOGNAND i1 i2 [Function]",
	"LOGNOR",					"LOGNOR i1 i2 [Function]",
	"LOGNOT",					"LOGNOT i [Function]",
	"LOGORC1",					"LOGORC1 i1 i2 [Function]",
	"LOGORC2",					"LOGORC2 i1 i2 [Function]",
	"LOGTEST",					"LOGTEST i1 i2 [Function]",
	"LOGXOR",					"LOGXOR &rest is [Function]",
	"MAKE-RANDOM-STATE",		"MAKE-RANDOM-STATE &optional state [Function]",
	"MASK-FIELD",				"MASK-FIELD spec i [Function]",
	"MAX",						"MAX rl &rest rs [Function]",
	"MIN",						"MIN rl &rest rs [Function]",
	"MINUSP",					"MINUSP r [Function]",
	"MOD",						"MOD r1 r2 [Function]",
	"NUMBERP",					"NUMBERP object [Function]",
	"NUMERATOR",				"NUMERATOR rational [Function]",
	"ODDP",						"ODDP i [Function]",
	"PARSE-INTEGER",			"PARSE-INTEGER string &key start end radix junk-allowed [Function]",
	"PHASE",					"PHASE n [Function]",
	"PLUSP",					"PLUSP r [Function]",
	"RANDOM",					"RANDOM limit &optional (state *random-state*) [Function]",
	"RANDOM-STATE-P",			"RANDOM-STATE-P object [Function]",
	"RATIONAL",					"RATIONAL r [Function]",
	"RATIONALIZE",				"RATIONALIZE r [Function]",
	"RATIONALP",				"RATIONALP object [Function]",
	"REALP",					"REALP object [Function]",
	"REALPART",					"REALPART n [Function]",
	"REM",						"REM r1 r2 [Function]",
	"ROUND",					"ROUND r &optional (d 1) [Function]",
	"SCALE-FLOAT",				"SCALE-FLOAT f i [Function]",
	"SIGNUM",					"SIGNUM n [Function]",
	"SIN",						"SIN n [Function]",
	"SINH",						"SINH n [Function]",
	"SQRT",						"SQRT n [Function]",
	"TAN",						"TAN n [Function]",
	"TANH",						"TANH n [Function]",
	"TRUNCATE",					"TRUNCATE r &optional (d 1) [Function]",
	"UPGRADED-COMPLEX-PART-TYPE","UPGRADED-COMPLEX-PART-TYPE type [Function]",
	"ZEROP",					"ZEROP n [Function]",
	"=",						"= n1 &rest ns [Function]",
	"/=",						"/= n1 &rest ns [Function]",
	">",						"> r1 &rest rs [Function]",
	"<",						"< r1 &rest rs [Function]",
	"<=",						"<= r1 &rest rs [Function]",
	">=",						">= r1 &rest rs [Function]",
	"*",						"* &rest ns [Function]",
	"+",						"+ &rest ns [Function]",
	"-",						"- n1 &rest ns [Function]",
	"/",						"/ n1 &rest ns [Function]",
	"1+",						"1+ n [Function]",
	"1-",						"1- n [Function]",
	
	// Characters
	"ALPHA-CHAR-P",				"ALPHA-CHAR-P char [Function]",
	"BOTH-CASE-P",				"BOTH-CASE-P char [Function]",
	"ALPHANUMERICP",			"ALPHANUMERICP char [Function]",
	"CHARACTER",				"CHARACTER c [Function]",
	"CHARACTERP",				"CHARACTERP object [Function]",
	"CHAR-CODE",				"CHAR-CODE char [Function]",
	"CHAR-DOWNCASE",			"CHAR-DOWNCASE char [Function]",
	"CHAR-GREATERP",			"CHAR-GREATERP char &rest chars [Function]",
	"CHAR-EQUAL",				"CHAR-EQUAL char1 &rest chars [Function]",
	"CHAR-INT",					"CHAR-INT char [Function]",
	"CHAR-LESSP",				"CHAR-LESSP char1 &rest chars [Function]",
	"CHAR-NAME",				"CHAR-NAME char [Function]",
	"CHAR-NOT-GREATERP",		"CHAR-NOT-GREATERP char1 &rest chars [Function]",
	"CHAR-NOT-EQUAL",			"CHAR-NOT-EQUAL char1 &rest chars [Function]",
	"CHAR-NOT-LESSP",			"CHAR-NOT-LESSP char1 &rest chars [Function]",
	"CHAR-UPCASE",				"CHAR-UPCASE char [Function]",
	"CHAR=",					"CHAR= char1 &rest chars [Function]",
	"CHAR/=",					"CHAR/= char1 &rest chars [Function]",
	"CHAR>",					"CHAR> char1 &rest chars [Function]",
	"CHAR<",					"CHAR< char1 &rest chars [Function]",
	"CHAR<=",					"CHAR<= char1 &rest chars [Function]",
	"CHAR>=",					"CHAR>=< char1 &rest chars [Function]",
	"CODE-CHAR",				"CODE-CHAR code [Function]",
	"DIGIT-CHAR",				"DIGIT-CHAR i &optional (r 10) [Function]",
	"DIGIT-CHAR-P",				"DIGIT-CHAR-P char &optional (r 10) [Function]",
	"GRAPHIC-CHAR-P",			"GRAPHIC-CHAR-P char [Function]",
	"LOWER-CASE-P",				"LOWER-CASE-P char [Function]",
	"NAME-CHAR",				"NAME-CHAR name [Function]",
	"STANDARD-CHAR-P",			"STANDARD-CHAR-P char [Function]",
	"UPPER-CASE-P",				"UPPER-CASE-P char [Function]",
	
	// Conses
	"ACONS",					"ACONS key value alist [Function]",
	"ADJOIN",					"ADJOIN object prolist &key key test test-not [Function]",
	"APPEND",					"APPEND &rest prolists [Function]",
	"ASSOC",					"ASSOC key alist &key key test test-not [Function]",
	"ASSOC-IF",					"ASSOC-IF predicate alist &key key [Function]",
	"ASSOC-IF-NOT",				"ASSOC-IF-NOT predicate alist &key key [Function]",
	"ATOM",						"ATOM object [Function]",
	"BUTLAST",					"BUTLAST list &optional (n 1) [Function]",
	"NBUTLAST",					"NBUTLAST <list> &optional (n 1) [Function]",
	"CAR",						"CAR list [Function]",
	"CDR",						"CDR list [Function]",
	"CAAR",						"CAAR list [Function]",
	"CADR",						"CADR list [Function]",
	"CDAR",						"CDAR list [Function]",
	"CDDR",						"CDDR list [Function]",
	"CAAAR",					"CAAAR list [Function]",
	"CAADR",					"CAADR list [Function]",
	"CADAR",					"CADAR list [Function]",
	"CADDR",					"CADDR list [Function]",
	"CDAAR",					"CDAAR list [Function]",
	"CDADR",					"CDADR list [Function]",
	"CDDAR",					"CDDAR list [Function]",
	"CDDDR",					"CDDDR list [Function]",
	"CAAAAR",					"CAAAAR list [Function]",
	"CAAADR",					"CAAADR list [Function]",
	"CAADAR",					"CAADAR list [Function]",
	"CAADDR",					"CAADDR list [Function]",
	"CADAAR",					"CADAAR list [Function]",
	"CADADR",					"CADADR list [Function]",
	"CADDAR",					"CADDAR list [Function]",
	"CADDDR",					"CADDDR list [Function]",
	"CDAAAR",					"CDAAAR list [Function]",
	"CDAADR",					"CDAADR list [Function]",
	"CDADAR",					"CDADAR list [Function]",
	"CDADDR",					"CDADDR list [Function]",
	"CDDAAR",					"CDDAAR list [Function]",
	"CDDADR",					"CDDADR list [Function]",
	"CDDDAR",					"CDDDAR list [Function]",
	"CDDDDR",					"CDDDDR list [Function]",
	"CONS",						"CONS object1 object2 [Function]",
	"CONSP",					"CONSP object [Function]",
	"COPY-ALIST",				"COPY-ALIST alist [Function]",
	"COPY-LIST",				"COPY-LIST list [Function]",
	"COPY-TREE",				"COPY-TREE tree [Function]",
	"ENDP",						"ENDP list [Function]",
	"FIRST",					"FIRST list [Function]",
	"SECOND",					"SECOND list [Function]",
	"THIRD",					"THIRD list [Function]",
	"FOURTH",					"FOURTH list [Function]",
	"FIFTH",					"FIFTH list [Function]",
	"SIXTH",					"SIXTH list [Function]",
	"SEVENTH",					"SEVENTH list [Function]",
	"EIGHTH",					"EIGHTH list [Function]",
	"NINTH",					"NINTH list [Function]",
	"TENTH",					"TENTH list [Function]",
	"GETF",						"GETF plist key &optional (default nil) [Function]",
	"GET-PROPERTIES",			"GET-PROPERTIES plist prolist [Function]",
	"INTERSECTION",				"INTERSECTION prolist1 prolist2 &key key test test-not [Function]",
	"NINTERSECTION",			"NINTERSECTION <prolist1> prolist2 &key key test test-not [Function]",
	"LAST",						"LAST list &optional (n 1) [Function]",
	"LDIFF",					"LDIFF list object [Function]",
	"LIST",						"LIST &rest objects [Function]",
	"LIST*",					"LIST* object &rest objects [Function]",
	"LIST-LENGTH",				"LIST-LENGTH list [Function]",
	"LISTP",					"LISTP object [Function]",
	"MAKE-LIST",				"MAKE-LIST n &key (initial-element nil) [Function]",
	"MAPC",						"MAPC function prolist &rest prolists [Function]",
	"MAPCAN",					"MAPCAN function prolist &rest prolists [Function]",
	"MAPCAR",					"MAPCAR function prolist &rest prolists [Function]",
	"MAPCON",					"MAPCON function prolist &rest prolists [Function]",
	"MAPL",						"MAPL function prolist &rest prolists [Function]",
	"MAPLIST",					"MAPLIST function prolist &rest prolists [Function]",
	"MEMBER",					"MEMBER object prolist &key key test test-not [Function]",
	"MEMBER-IF",				"MEMBER-IF predicate prolist &key key test test-not [Function]",
	"MEMBER-IF-NOT",			"MEMBER-IF-NOT predicate prolist &key key test test-not [Function]",
	"NCONC",					"NCONC &rest <lists> [Function]",
	"NTH",						"NTH n list [Function]",
	"NTHCDR",					"NTHCDR n list [Function]",
	"NULL",						"NULL object [Function]",
	"PAIRLIS",					"PAIRLIS key values &optional alist [Function]",
	"POP",						"POP <place> [Macro]",
	"PUSH",						"PUSH object <place> [Macro]",
	"PUSHNEW",					"PUSHNEW object <place> &key key test test-not [Macro]",
	"RASSOC",					"RASSOC key alist &key key test test-not [Function]",
	"RASSOC-IF",				"RASSOC-IF predicate alist &key key [Function]",
	"RASSOC-IF-NOT",			"RASSOC-IF-NOT predicate alist &key key [Function]",
	"REMF",						"REMF <place> key [Macro]",
	"REST",						"REST list [Function]",
	"REVAPPEND",				"REVAPPEND list1 list2 [Function]",
	"NRECONC",					"NRECONC <list1> list2 [Function]",
	"RPLACA",					"RPLACA <cons> object [Function]",
	"RPLACD",					"RPLACD <cons> object [Function]",
	"SET-DIFFERENCE",			"SET-DIFFERENCE prolist1 prolist2 &key key test test-not [Function]",
	"NSET-DIFFERENCE",			"NSET-DIFFERENCE <prolist1> prolist2 &key key test test-not [Function]",
	"SET-EXCLUSIVE-OR",			"SET-EXCLUSIVE-OR prolist1 prolist2 &key key test test-not [Function]",
	"NSET-EXCLUSIVE-OR",		"NSET-EXCLUSIVE-OR <prolist1> <prolist2> &key key test test-not [Function]",
	"SUBLIS",					"SUBLIS alist tree &key key test test-not [Function]",
	"NSUBLIS",					"NSUBLIS alist <tree> &key key test test-not [Function]",
	"SUBSETP",					"SUBSETP prolist1 prolist2 &key key test test-not [Function]",
	"SUBST",					"SUBST new old tree &key key test test-not [Function]",
	"NSUBST",					"NSUBST new old <tree> &key key test test-not [Function]",
	"SUBST-IF",					"SUBST-IF new predicate tree &key key [Function]",
	"NSUBST-IF",				"NSUBST-IF new predicate <tree> &key key [Function]",
	"SUBST-IF-NOT",				"SUBST-IF-NOT new predicate tree &key key [Function]",
	"NSUBST-IF-NOT",			"NSUBST-IF-NOT new predicate <tree> &key key [Function]",
	"TAILP",					"TAILP object list [Function]",
	"TREE-EQUAL",				"TREE-EQUAL tree1 tree2 &key test test-not [Function]",
	"UNION",					"UNION prolist1 prolist2 &key key test test-not [Function]",
	"NUNION",					"NUNION <prolist1> <prolist2> &key key test test-not [Function]",
	
	// Arrays
	"ADJUSTABLE-ARRAY-P",		"ADJUSTABLE-ARRAY-P array [Function]",
	"ADJUST-ARRAY",				"ADJUST-ARRAY <array> dimensions &key ... [Function]",
	"AREF",						"AREF array &rest is [Function]",
	"ARRAY-DIMENSION",			"ARRAY-DIMENSION array i [Function]",
	"ARRAY-DIMENSIONS",			"ARRAY-DIMENSIONS array [Function]",
	"ARRAY-DISPLACEMENT",		"ARRAY-DISPLACEMENT array [Function]",
	"ARRAY-ELEMENT-TYPE",		"ARRAY-ELEMENT-TYPE array [Function]",
	"ARRAY-HAS-FILL-POINTER-P",	"ARRAY-HAS-FILL-POINTER-P array [Function]",
	"ARRAY-IN-BOUNDS-P",		"ARRAY-IN-BOUNDS-P array &rest is [Function]",
	"ARRAYP",					"ARRAYP object [Function]",
	"ARRAY-RANK",				"ARRAY-RANK array [Function]",
	"ARRAY-ROW-MAJOR-INDEX",	"ARRAY-ROW-MAJOR-INDEX array &rest is [Function]",
	"ARRAY-TOTAL-SIZE",			"ARRAY-TOTAL-SIZE array [Function]",
	"BIT",						"BIT bit-array &rest is [Function]",
	"BIT-AND",					"BIT-AND <bit-array1> bit-array2 &optional <arg> [Function]",
	"BIT-ANDC1",				"BIT-ANDC1 <bit-array1> bit-array2 &optional <arg> [Function]",
	"BIT-ANDC2",				"BIT-ANDC2 <bit-array1> bit-array2 &optional <arg> [Function]",
	"BIT-EQV",					"BIT-EQV <bit-array1> bit-array2 &optional <arg> [Function]",
	"BIT-IOR",					"BIT-IOR <bit-array1> bit-array2 &optional <arg> [Function]",
	"BIT-NAND",					"BIT-NAND <bit-array1> bit-array2 &optional <arg> [Function]",
	"BIT-NOR",					"BIT-NOR <bit-array1> bit-array2 &optional <arg> [Function]",
	"BIT-NOT",					"BIT-NOT <bit-array> &optional <arg> [Function]",
	"BIT-ORC1",					"BIT-ORC1 <bit-array1> bit-array2 &optional <arg> [Function]",
	"BIT-ORC2",					"BIT-ORC2 <bit-array1> bit-array2 &optional <arg> [Function]",
	"BIT-XOR",					"BIT-XOR <bit-array1> bit-array2 &optional <arg> [Function]",
	"BIT-VECTOR-P",				"BIT-VECTOR-P object [Function]",
	"FILL-POINTER",				"FILL-POINTER vector [Function]",
	"MAKE-ARRAY",				"MAKE-ARRAY dimensions &key element-type initial-element initial-contents adjustable fill-pointer displaced-to displaced-index-offset [Function]",
	"ROW-MAJOR-AREF",			"ROW-MAJOR-AREF array i [Function]",
	"SBIT",						"SBIT simple-bit-array &rest is [Function]",
	"SIMPLE-BIT-VECTOR-P",		"SIMPLE-BIT-VECTOR-P object [Function]",
	"SVREF",					"SVREF simple-vector i [Function]",
	"UPGRADED-ARRAY-ELEMENT-TYPE","UPGRADED-ARRAY-ELEMENT-TYPE type &optional &env [Function]",
	"VECTOR",					"VECTOR &rest objects [Function]",
	"VECTORP",					"VECTORP object [Function]",
	"VECTOR-POP",				"VECTOR-POP vector [Function]",
	"VECTOR-PUSH",				"VECTOR-PUSH object vector [Function]",
	"VECTOR-PUSH-EXTEND",		"VECTOR-PUSH-EXTEND object vector &optional i [Function]",
	
	// Strings
	"CHAR",						"CHAR string i [Function]",
	"MAKE-STRING",				"MAKE-STRING n &key initial-element (element-type 'character) [Function]",
	"SCHAR",					"SCHAR simple-string i [Function]",
	"SIMPLE-STRING-P",			"SIMPLE-STRING-P object [Function]",
	"STRING",					"STRING arg [Function]",
	"STRING-CAPITALIZE",		"STRING-CAPITALIZE string &key start end [Function]",
	"NSTRING-CAPITALIZE",		"NSTRING-CAPITALIZE <string> &key start end [Function]",
	"STRING-DOWNCASE",			"STRING-DOWNCASE string &key start end [Function]",
	"NSTRING-DOWNCASE",			"NSTRING-DOWNCASE <string> &key start end [Function]",
	"STRING-EQUAL",				"STRING-EQUAL string1 string2 &key start1 end1 start2 end2 [Function]",
	"STRING-GREATERP",			"STRING-GREATERP string1 string2 &key start1 end1 start2 end2 [Function]",
	"STRING-UPCASE",			"STRING-UPCASE string &key start end [Function]",
	"NSTRING-UPCASE",			"NSTRING-UPCASE <string> &key start end [Function]",
	"STRING-LEFT-TRIM",			"STRING-LEFT-TRIM seq string [Function]",
	"STRING-LESSP",				"STRING-LESSP string1 string2 &key start1 end1 start2 end2 [Function]",
	"STRING-NOT-EQUAL",			"STRING-NOT-EQUAL string1 string2 &key start1 end1 start2 end2 [Function]",
	"STRING-NOT-GREATERP",		"STRING-NOT-GREATERP string1 string2 &key start1 end1 start2 end2 [Function]",
	"STRING-NOT-LESSP",			"STRING-NOT-LESSP string1 string2 &key start1 end1 start2 end2 [Function]",
	"STRINGP",					"STRINGP object [Function]",
	"STRING-RIGHT-TRIM",		"STRING-RIGHT-TRIM seq string [Function]",
	"STRING-TRIM",				"STRING-TRIM seq string [Function]",
	"STRING=",					"STRING= string1 string2 &key start1 end1 start2 end2 [Function]",
	"STRING/=",					"STRING/= string1 string2 &key start1 end1 start2 end2 [Function]",
	"STRING<",					"STRING< string1 string2 &key start1 end1 start2 end2 [Function]",
	"STRING>",					"STRING> string1 string2 &key start1 end1 start2 end2 [Function]",
	"STRING<=",					"STRING<= string1 string2 &key start1 end1 start2 end2 [Function]",
	"STRING>=",					"STRING>= string1 string2 &key start1 end1 start2 end2 [Function]",

	// Sequences
	"CONCATENATE",				"CONCATENATE type &rest sequences [Function]",
	"COPY-SEQ",					"COPY-SEQ proseq [Function]",
	"COUNT",					"COUNT object proseq &key key test test-not from-end start end [Function]",
	"COUNT-IF",					"COUNT-IF predicate proseq &key key from-end start end [Function]",
	"COUNT-IF-NOT",				"COUNT-IF-NOT predicate proseq &key key from-end start end [Function]",
	"ELT",						"ELT proseq n [Function]",
	"FILL",						"FILL <proseq> object &key start end [Function]",
	"FIND",						"FIND object proseq &key key test test-not from-end start end [Function]",
	"FIND-IF",					"FIND-IF predicate proseq &key key from-end start end [Function]",
	"FIND-IF-NOT",				"FIND-IF-NOT predicate proseq &key key from-end start end [Function]",
	"LENGTH",					"LENGTH proseq [Function]",
	"MAKE-SEQUENCE",			"MAKE-SEQUENCE type n &key (initial-element nil) [Function]",
	"MAP",						"MAP type function proseq &rest proseqs [Function]",
	"MAP-INTO",					"MAP-INTO <result> function proseq &rest proseqs [Function]",
	"MERGE",					"MERGE type <sequence1> <sequence2> predicate &key key [Function]",
	"MISMATCH",					"MISMATCH sequence1 sequence2 &key key test test-not from-end start1 end1 start2 end2 [Function]",
	"POSITION",					"POSITION object proseq &key key test test-not from-end start end [Function]",
	"POSITION-IF",				"POSITION-IF predicate proseq &key key from-end start end [Function]",
	"POSITION-IF-NOT",			"POSITION-IF-NOT predicate proseq &key key from-end start end [Function]",
	"REDUCE",					"REDUCE function proseq &key key from-end start end initial-value [Function]",
	"REMOVE",					"REMOVE object proseq &key key test test-not from-end start end count [Function]",
	"DELETE",					"DELETE object <proseq> &key key test test-not from-end start end count [Function]",
	"REMOVE-DUPLICATES",		"REMOVE-DUPLICATES proseq &key key test test-not from-end start end [Function]",
	"DELETE-DUPLICATES",		"DELETE-DUPLICATES <proseq> &key key test test-not from-end start end [Function]",
	"REMOVE-IF",				"REMOVE-IF predicate proseq &key key from-end start end count [Function]",
	"DELETE-IF",				"DELETE-IF predicate <proseq> &key key from-end start end count [Function]",
	"REMOVE-IF-NOT",			"REMOVE-IF-NOT predicate proseq &key key from-end start end count [Function]",
	"DELETE-IF-NOT",			"DELETE-IF-NOT predicate <proseq> &key key from-end start end count [Function]",
	"REPLACE",					"REPLACE <sequence1> sequence2 &key start1 end1 start2 end2 [Function]",
	"REVERSE",					"REVERSE proseq [Function]",
	"NREVERSE",					"NREVERSE proseq [Function]",
	"SEARCH",					"SEARCH sequence1 sequence2 &key key test test-not from-end start1 end1 start2 end2 [Function]",
	"SORT",						"SORT <proseq> predicate &key key [Function]",
	"STABLE-SORT",				"STABLE-SORT <proseq> predicate &key key [Function]",
	"SUBSEQ",					"SUBSEQ proseq start &optional end [Function]",
	"SUBSTITUTE",				"SUBSTITUTE new old proseq &key key test test-not from-end start end count [Function]",
	"NSUBSTITUTE",				"NSUBSTITUTE new old <proseq> &key key test test-not from-end start end count [Function]",
	"SUBSTITUTE-IF",			"SUBSTITUTE-IF new predicate proseq &key key from-end start end count [Function]",
	"NSUBSTITUTE-IF",			"NSUBSTITUTE-IF new predicate <proseq> &key key from-end start end count [Function]",
	"SUBSTITUTE-IF-NOT",		"SUBSTITUTE-IF-NOT new predicate proseq &key key from-end start end count [Function]",
	"NSUBSTITUTE-IF-NOT",		"NSUBSTITUTE-IF-NOT new predicate <proseq> &key key from-end start end count [Function]",
	
	// Hash Tables
	"CLRHASH",					"CLRHASH hash-table [Function]",
	"GETHASH",					"GETHASH key hash-table &optional default [Function]",
	"HASH-TABLE-COUNT",			"HASH-TABLE-COUNT hash-table [Function]",
	"HASH-TABLE-P",				"HASH-TABLE-P object [Function]",
	"HASH-TABLE-REHASH-SIZE",	"HASH-TABLE-REHASH-SIZE hash-table [Function]",
	"HASH-TABLE-REHASH-THRESHOLD","HASH-TABLE-REHASH-THRESHOLD hash-table [Function]",
	"HASH-TABLE-SIZE",			"HASH-TABLE-SIZE hash-table [Function]",
	"HASH-TABLE-TEST",			"HASH-TABLE-TEST hash-table [Function]",
	"MAKE-HASH-TABLE",			"MAKE-HASH-TABLE &key test size rehash-size rehash-threshold [Function]",
	"MAPHASH",					"MAPHASH function hash-table [Function]",
	"REMHASH",					"REMHASH key <hash-table> [Function]",
	"SXHASH",					"SXHASH object [Function]",
	"WITH-HASH-TABLE-ITERATOR",	"WITH-HASH-TABLE-ITERATOR (symbol hash-table) declaration* expression* [Macro]",
	
	// Filenames
	"DIRECTORY-NAMESTRING",		"DIRECTORY-NAMESTRING path [Function]",
	"ENOUGH-NAMESTRING",		"ENOUGH-NAMESTRING path &optional path2 [Function]",
	"FILE-NAMESTRING",			"FILE-NAMESTRING path [Function]",
	"HOST-NAMESTRING",			"HOST-NAMESTRING path [Function]",
	"LOAD-LOGICAL-PATHNAME-TRANSLATIONS","LOAD-LOGICAL-PATHNAME-TRANSLATIONS string [Function]",
	"LOGICAL-PATHNAME",			"LOGICAL-PATHNAME path [Function]",
	"LOGICAL-PATHNAME-TRANSLATIONS","LOGICAL-PATHNAME-TRANSLATIONS host [Function]",
	"MAKE-PATHNAME",			"MAKE-PATHNAME &key host device directory name type version defaults case [Function]",
	"MERGE-PATHNAMES",			"MERGE-PATHNAMES path &optional default-path version [Function]",
	"NAMESTRING",				"NAMESTRING path [Function]",
	"PARSE-NAMESTRING",			"PARSE-NAMESTRING path &optional host default &key start end junk-allowed [Function]",
	"PATHNAME",					"PATHNAME path [Function]",
	"PATHNAME-HOST",			"PATHNAME-HOST path &key case [Function]",
	"PATHNAME-DEVICE",			"PATHNAME-DEVICE path &key case [Function]",
	"PATHNAME-DIRECTORY",		"PATHNAME-DIRECTORY path &key case [Function]",
	"PATHNAME-MATCH-P",			"PATHNAME-MATCH-P path wild-path [Function]",
	"PATHNAME-NAME",			"PATHNAME-NAME path &key case [Function]",
	"PATHNAMEP",				"PATHNAMEP object [Function]",
	"PATHNAME-TYPE",			"PATHNAME-TYPE path &key case [Function]",
	"PATHNAME-VERSION",			"PATHNAME-VERSION path &key case [Function]",
	"TRANSLATE-LOGICAL-PATHNAME","TRANSLATE-LOGICAL-PATHNAME path &key [Function]",
	"TRANSLATE-PATHNAME",		"TRANSLATE-PATHNAME path1 path2 path3 &key [Function]",
	"WILD-PATHNAME-P",			"WILD-PATHNAME-P path &optional component [Function]",
	
	// Files
	"DELETE-FILE",				"DELETE-FILE path [Function]",
	"DIRECTORY",				"DIRECTORY path &key [Function]",
	"ENSURE-DIRECTORIES-EXIST", "ENSURE-DIRECTORIES-EXIST path &key verbose [Function]",
	"FILE-AUTHOR",				"FILE-AUTHOR path [Function]",
	"FILE-ERROR-PATHNAME",		"FILE-ERROR-PATHNAME condition [Function]",
	"FILE-WRITE-DATE",			"FILE-WRITE-DATE path [Function]",
	"PROBE-FILE",				"PROBE-FILE path [Function]",
	"RENAME-FILE",				"RENAME-FILE path1 path2 [Function]",
	"TRUENAME",					"TRUENAME path [Function]",
	
	// Streams
	"BROADCAST-STREAM-STREAMS",	"BROADCAST-STREAM-STREAMS broadcast-stream [Function]",
	"CLEAR-INPUT",				"CLEAR-INPUT &optional stream [Function]",
	"CLEAR-OUTPUT",				"CLEAR-OUTPUT &optional stream [Function]",
	"CLOSE",					"CLOSE stream &key abort [Function]",
	"CONCATENATED-STREAM-STREAMS","CONCATENATED-STREAM-STREAMS concatenated-stream [Function]",
	"ECHO-STREAM-INPUT-STREAM",	"ECHO-STREAM-INPUT-STREAM echo-stream [Function]",
	"ECHO-STREAM-OUTPUT-STREAM","ECHO-STREAM-OUTPUT-STREAM echo-stream [Function]",
	"FILE-LENGTH",				"FILE-LENGTH stream [Function]",
	"FILE-POSITION",			"FILE-POSITION stream &optional pos [Function]",
	"FILE-STRING-LENGTH",		"FILE-STRING-LENGTH stream object [Function]",
	"FINISH-OUTPUT",			"FINISH-OUTPUT &optional stream [Function]",
	"FORCE-OUTPUT",				"FORCE-OUTPUT &optional stream [Function]",
	"FRESH-LINE",				"FRESH-LINE &optional stream [Function]",
	"GET-OUTPUT-STREAM-STRING",	"GET-OUTPUT-STREAM-STRING stream [Function]",
	"INPUT-STREAM-P",			"INPUT-STREAM-P stream [Function]",
	"INTERACTIVE-STREAM-P",		"INTERACTIVE-STREAM-P stream [Function]",
	"LISTEN",					"LISTEN &optional stream [Function]",
	"MAKE-BROADCAST-STREAM",	"MAKE-BROADCAST-STREAM &rest streams [Function]",
	"MAKE-CONCATENATED-STREAM",	"MAKE-CONCATENATED-STREAM &rest input-streams [Function]",
	"MAKE-ECHO-STREAM",			"MAKE-ECHO-STREAM input-stream output-stream [Function]",
	"MAKE-STRING-INPUT-STREAM", "MAKE-STRING-INPUT-STREAM string &optional start end [Function]",
	"MAKE-STRING-OUTPUT-STREAM","MAKE-STRING-OUTPUT-STREAM &key element-type [Function]",
	"MAKE-SYNONYM-STREAM",		"MAKE-SYNONYM-STREAM symbol [Function]",
	"MAKE-TWO-WAY-STREAM",		"MAKE-TWO-WAY-STREAM input-stream output-stream [Function]",
	"OPEN",						"OPEN path &key direction element-type if-exists if-does-not-exist external-format [Function]",
	"OPEN-STREAM-P",			"OPEN-STREAM-P stream [Function]",
	"OUTPUT-STREAM-P",			"OUTPUT-STREAM-P stream [Function]",
	"PEEK-CHAR",				"PEEK-CHAR &optional kind stream eof-error eof-value recursive [Function]",
	"READ-BYTE",				"READ-BYTE stream &optional eof-error eof-value [Function]",
	"READ-CHAR",				"READ-CHAR &optional stream eof-error eof-value recursive [Function]",
	"READ-CHAR-NO-HANG",		"READ-CHAR-NO-HANG &optional stream eof-error eof-value recursive [Function]",
	"READ-LINE",				"READ-LINE &optional stream eof-error eof-value recursive [Function]",
	"READ-SEQUENCE",			"READ-SEQUENCE <proseq> &optional stream &key start end [Function]",
	"STREAM-ELEMENT-TYPE",		"STREAM-ELEMENT-TYPE stream [Function]",
	"STREAM-ERROR-STREAM",		"STREAM-ERROR-STREAM condition [Function]",
	"STREAM-EXTERNAL-FORMAT",	"STREAM-EXTERNAL-FORMAT stream [Function]",
	"STREAMP",					"STREAMP object [Function]",
	"SYNONYM-STREAM-SYMBOL",	"SYNONYM-STREAM-SYMBOL synonym-stream [Function]",
	"TERPRI",					"TERPRI &optional stream [Function]",
	"TWO-WAY-STREAM-INPUT-STREAM","TWO-WAY-STREAM-INPUT-STREAM  two-way-stream [Function]",
	"TWO-WAY-STREAM-OUTPUT-STREAM","TWO-WAY-STREAM-OUTPUT-STREAM  two-way-stream [Function]",
	"UNREAD-CHAR",				"UNREAD-CHAR character &optional stream [Function]",
	"WITH-INPUT-FROM-STRING",	"WITH-INPUT-FROM-STRING (symbol string &key index start end) declaration* expression* [Macro]",
	"WITH-OPEN-FILE",			"WITH-OPEN-FILE (symbol path arg*) declaration* expression* [Macro]",
	"WITH-OPEN-STREAM",			"WITH-OPEN-STREAM (symbol stream) declaration* expression* [Macro]",
	"WITH-OUTPUT-TO-STRING",	"WITH-OUTPUT-TO-STRING (symbol [string] &key element-type) declaration* expression* [Macro]",
	"WRITE-BYTE",				"WRITE-BYTE i stream [Function]",
	"WRITE-CHAR",				"WRITE-CHAR character &optional stream [Function]",
	"WRITE-LINE",				"WRITE-LINE string &optional stream &key start end [Function]",
	"WRITE-SEQUENCE",			"WRITE-SEQUENCE proseq &optional stream &key start end [Function]",
	"WRITE-STRING",				"WRITE-STRING string &optional stream &key start end [Function]",
	"YES-OR-NO-P",				"YES-OR-NO-P &optional format &rest args [Function]",
	"Y-OR-N-P",					"Y-OR-N-P &optional format &rest args [Function]",

	// Printer
	"COPY-PPRINT-DISPATCH",		"COPY-PPRINT-DISPATCH &optional pprint-dispatch [Function]",
	"FORMAT",					"FORMAT dest format &rest args [Function]",
	"FORMATTER",				"FORMATTER string [Macro]",
	"PPRINT",					"PPRINT object &optional stream [Function]",
	"PPRINT-DISPATCH",			"PPRINT-DISPATCH object &optional pprint-dispatch [Function]",
	"PPRINT-EXIT-IF-LIST-EXHAUSTED","PPRINT-EXIT-IF-LIST-EXHAUSTED [Macro]",
	"PPRINT-FILL",				"PPRINT-FILL stream object &optional colon at [Function]",
	"PPRINT-INDENT",			"PPRINT-INDENT keyword r &optional stream [Function]",
	"PPRINT-LINEAR",			"PPRINT-LINEAR stream object &optional colon at [Function]",
	"PPRINT-LOGICAL-BLOCK",		"PPRINT-LOGICAL-BLOCK (symbol object &key prefix per-line-prefix suffix) declaration* expression* [Macro]",
	"PPRINT-NEWLINE",			"PPRINT-NEWLINE keyword &optional stream [Function]",
	"PPRINT-POP",				"PPRINT-POP [Macro]",
	"PPRINT-TAB",				"PPRINT-TAB keyword i1 i2 &optional stream [Function]",
	"PPRINT-TABULAR",			"PPRINT-TABULAR stream object &optional colon at tab [Function]",
	"PRINC",					"PRINC object &optional stream [Function]",
	"PRINC-TO-STRING",			"PRINC-TO-STRING object [Function]",
	"PRINT",					"PRINT object &optional stream [Function]",
	"PRINT-OBJECT",				"PRINT-OBJECT object stream [Generic Function]",
	"PRINT-NOT-READABLE-OBJECT","PRINT-NOT-READABLE-OBJECT condition [Function]",
	"PRINT-UNREADABLE-OBJECT",	"PRINT-UNREADABLE-OBJECT (object stream &key type identity) expression* [Macro]",
	"PRIN1",					"PRIN1 object &optional stream [Function]",
	"PRIN1-TO-STRING",			"PRIN1-TO-STRING object [Function]",
	"SET-PPRINT-DISPATCH",		"SET-PPRINT-DISPATCH type function &optional r pprint-dispatch [Function]",
	"WRITE",					"WRITE object &key array base case circle escape gensym length level lines miser-width pprint-dispatch pretty radix readably right-margin stream [Function]",
	"WRITE-TO-STRING",			"WRITE-TO-STRING object &key array base case circle escape gensym length level lines miser-width pprint-dispatch pretty radix readably right-margin stream [Function]", 

	// Reader
	"COPY-READTABLE",			"COPY-READTABLE &optional from <to> [Function]",
	"GET-DISPATCH-MACRO-CHARACTER","GET-DISPATCH-MACRO-CHARACTER char1 char2 &optional readtable [Function]",
	"GET-MACRO-CHARACTER",		"GET-MACRO-CHARACTER char &optional readtable [Function]",
	"MAKE-DISPATCH-MACRO-CHARACTER","MAKE-DISPATCH-MACRO-CHARACTER char &optional nonterm readtable [Function]",
	"READ",						"READ &optional stream eof-error eof-value recursive [Function]",
	"READ-DELIMITED-LIST",		"READ-DELIMITED-LIST char &optional stream recursive [Function]",
	"READ-FROM-STRING",			"READ-FROM-STRING string &optional eof-error eof-value &key start end preserve-whitespace [Function]",
	"READ-PRESERVING-WHITESPACE","READ-PRESERVING-WHITESPACE &optional stream eof-error eof-value recursive [Function]",
	"READTABLE-CASE",			"READTABLE-CASE readtable [Function]",
	"READTABLEP",				"READTABLEP object [Function]",
	"SET-DISPATCH-MACRO-CHARACTER","SET-DISPATCH-MACRO-CHARACTER char1 char2 function &optional readtable [Function]",
	"SET-MACRO-CHARACTER",		"SET-MACRO-CHARACTER char function &optional nonterm readtable [Function]",
	"SET-SYNTAX-FROM-CHAR",		"SET-SYNTAX-FROM-CHAR to-char from-char &optional to-readtable from-readtable [Function]",
	"WITH-STANDARD-IO-SYNTAX",	"WITH-STANDARD-IO-SYNTAX expression* [Macro]",

	// System Construction
	"COMPILE-FILE",				"COMPILE-FILE path &key output-file verbose print external-format [Function]",
	"COMPILE-FILE-PATHNAME",	"COMPILE-FILE-PATHNAME path &key output-file [Function]",
	"LOAD",						"LOAD path &key verbose print if-does-not-exist external-format [Function]",
	"PROVIDE",					"PROVIDE name [Function]",
	"REQUIRE",					"REQUIRE name &optional paths [Function]",
	"WITH-COMPILATION-UNIT",	"WITH-COMPILATION-UNIT ([:override val]) expression* [Macro]",
	
	// Environment
	"APROPOS",					"APROPOS name &optional package [Function]",
	"APROPOS-LIST",				"APROPOS-LIST name &optional package [Function]",
	"DECODE-UNIVERSAL-TIME",	"DECODE-UNIVERSAL-TIME i &optional time-zone [Function]",
	"DESCRIBE",					"DESCRIBE object &optional stream [Function]",
	"DESCRIBE-OBJECT",			"DESCRIBE-OBJECT object &optional stream [Generic Function]",
	"DISASSEMBLE",				"DISASSEMBLE fn [Function]",
	"DOCUMENTATION",			"DOCUMENTATION object symbol [Function]",
	"DRIBBLE",					"DRIBBLE &optional path [Function]",
	"ED",						"ED &optional arg [Function]",
	"ENCODE-UNIVERSAL-TIME",	"ENCODE-UNIVERSAL-TIME second minute hour date month year &optional time-zone [Function]",
	"GET-DECODED-TIME",			"GET-DECODED-TIME [Function]",
	"GET-INTERNAL-REAL-TIME",	"GET-INTERNAL-REAL-TIME [Function]",
	"GET-INTERNAL-RUN-TIME",	"GET-INTERNAL-RUN-TIME [Function]",
	"GET-UNIVERSAL-TIME",		"GET-UNIVERSAL-TIME [Function]",
	"INSPECT",					"INSPECT object [Function]",
	"LISP-IMPLEMENTATION-TYPE",	"LISP-IMPLEMENTATION-TYPE [Function]",
	"LISP-IMPLEMENTATION-VERSION","LISP-IMPLEMENTATION-VERSION [Function]",
	"LONG-SITE-NAME",			"LONG-SITE-NAME [Function]",
	"MACHINE-INSTANCE",			"MACHINE-INSTANCE [Function]",
	"MACHINE-TYPE",				"MACHINE-TYPE [Function]",
	"MACHINE-VERSION",			"MACHINE-VERSION [Function]",
	"ROOM",						"ROOM &optional (arg :default) [Function]",
	"SHORT-SITE-NAME",			"SHORT-SITE-NAME [Function]",
	"SLEEP",					"SLEEP r [Function]",
	"SOFTWARE-TYPE",			"SOFTWARE-TYPE [Function]",
	"SOFTWARE-VERSION",			"SOFTWARE-VERSION [Function]",
	"STEP",						"STEP expression [Macro]",
	"TIME",						"TIME expression [Macro]",
	"TRACE",					"TRACE fname* [Macro]",
	"UNTRACE",					"UNTRACE fname* [Macro]",
	"USER-HOMEDIR-PATHNAME",	"USER-HOMEDIR-PATHNAME &optional host [Function]",

	// Constants and Variables
	"ARRAY-DIMENSION-LIMIT",				"ARRAY-DIMENSION-LIMIT [Constant]",
	"ARRAY-RANK-LIMIT",						"ARRAY-RANK-LIMIT [Constant]",
	"ARRAY-TOTAL-SIZE-LIMIT",				"ARRAY-TOTAL-SIZE-LIMIT [Constant]",
	"BOOLE-1",								"BOOLE-1 [Constant]",
	// ...
	"BOOLE-XOR",							"BOOLE-XOR [Constant]",
	"*BREAK-ON-SIGNALS*",					"*BREAK-ON-SIGNALS* [Variable]",
	"CALL-ARGUMENTS-LIMIT",					"CALL-ARGUMENTS-LIMIT [Constant]",
	"CHAR-CODE-LIMIT",						"CHAR-CODE-LIMIT [Constant]",
	"*COMPILE-FILE-PATHNAME*",				"*COMPILE-FILE-PATHNAME* [Variable]",
	"*COMPILE-FILE-TRUENAME*",				"*COMPILE-FILE-TRUENAME* [Variable]",
	"*COMPILE-PRINT*",						"*COMPILE-PRINT* [Variable]",
	"*COMPILE-VERBOSE*",					"*COMPILE-VERBOSE* [Variable]",
	"*DEBUG-IO*",							"*DEBUG-IO* [Variable]",
	"*DEBUGGER-HOOK*",						"*DEBUGGER-HOOK* [Variable]",
	"*DEFAULT-PATHNAME-DEFAULTS*",			"*DEFAULT-PATHNAME-DEFAULTS* [Variable]",
	"SHORT-FLOAT-EPSILON",					"SHORT-FLOAT-EPSILON [Constant]",
	"SINGLE-FLOAT-EPSILON",					"SINGLE-FLOAT-EPSILON [Constant]",
	"DOUBLE-FLOAT-EPSILON",					"DOUBLE-FLOAT-EPSILON [Constant]",
	"LONG-FLOAT-EPSILON",					"LONG-FLOAT-EPSILON [Constant]",
	"SHORT-FLOAT-NEGATIVE-EPSILON",			"SHORT-FLOAT-NEGATIVE-EPSILON [Constant]",
	"SINGLE-FLOAT-NEGATIVE-EPSILON",		"SINGLE-FLOAT-NEGATIVE-EPSILON [Constant]",
	"DOUBLE-FLOAT-NEGATIVE-EPSILON",		"DOUBLE-FLOAT-NEGATIVE-EPSILON [Constant]",
	"LONG-FLOAT-NEGATIVE-EPSILON",			"LONG-FLOAT-NEGATIVE-EPSILON [Constant]",
	"*ERROR-OUTPUT*",						"*ERROR-OUTPUT* [Variable]",
	"*FEATURES*",							"*FEATURES* [Variable]",
	"*GENSYM-COUNTER*",						"*GENSYM-COUNTER* [Variable]",
	"INTERNAL-TIME-UNITS-PER-SECOND",		"INTERNAL-TIME-UNITS-PER-SECOND [Constant]",
	"LAMBDA-LIST-KEYWORDS",					"LAMBDA-LIST-KEYWORDS [Constant]",
	"LAMBDA-PARAMETERS-LIMIT",				"LAMBDA-PARAMETERS-LIMIT [Constant]",
	"LEAST-NEGATIVE-SHORT-FLOAT",			"LEAST-NEGATIVE-SHORT-FLOAT [Constant]",
	"LEAST-NEGATIVE-SINGLE-FLOAT",			"LEAST-NEGATIVE-SINGLE-FLOAT [Constant]",
	"LEAST-NEGATIVE-DOUBLE-FLOAT",			"LEAST-NEGATIVE-DOUBLE-FLOAT [Constant]",
	"LEAST-NEGATIVE-LONG-FLOAT",			"LEAST-NEGATIVE-LONG-FLOAT [Constant]",
	"LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT","LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT [Constant]",
	"LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT","LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT [Constant]",
	"LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT","LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT [Constant]",
	"LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT",	"LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT [Constant]",
	"LEAST-POSITIVE-SHORT-FLOAT",			"LEAST-POSITIVE-SHORT-FLOAT [Constant]",
	"LEAST-POSITIVE-SINGLE-FLOAT",			"LEAST-POSITIVE-SINGLE-FLOAT [Constant]",
	"LEAST-POSITIVE-DOUBLE-FLOAT",			"LEAST-POSITIVE-DOUBLE-FLOAT [Constant]",
	"LEAST-POSITIVE-LONG-FLOAT",			"LEAST-POSITIVE-LONG-FLOAT [Constant]",
	"LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT","LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT [Constant]",
	"LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT","LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT [Constant]",
	"LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT","LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT [Constant]",
	"LEAST-POSITIVE-NORMALIZED-LONG-FLOAT",	"LEAST-POSITIVE-NORMALIZED-LONG-FLOAT [Constant]",
	"*LOAD-PATHNAME*",						"*LOAD-PATHNAME* [Variable]",
	"*LOAD-PRINT*",							"*LOAD-PRINT* [Variable]",
	"*LOAD-TRUENAME*",						"*LOAD-TRUENAME* [Variable]",
	"*LOAD-VERBOSE*",						"*LOAD-VERBOSE* [Variable]",
	"*MACROEXPAND-HOOK*",					"*MACROEXPAND-HOOK* [Variable]",
	"*MODULES*",							"*MODULES* [Variable]",
	"MOST-NEGATIVE-FIXNUM",					"MOST-NEGATIVE-FIXNUM [Constant]",
	"MOST-NEGATIVE-SHORT-FLOAT",			"MOST-NEGATIVE-SHORT-FLOAT [Constant]",
	"MOST-NEGATIVE-SINGLE-FLOAT",			"MOST-NEGATIVE-SINGLE-FLOAT [Constant]",
	"MOST-NEGATIVE-DOUBLE-FLOAT",			"MOST-NEGATIVE-DOUBLE-FLOAT [Constant]",
	"MOST-NEGATIVE-LONG-FLOAT",				"MOST-NEGATIVE-LONG-FLOAT [Constant]",
	"MOST-POSITIVE-FIXNUM",					"MOST-POSITIVE-FIXNUM [Constant]",
	"MOST-POSITIVE-SHORT-FLOAT",			"MOST-POSITIVE-SHORT-FLOAT [Constant]",
	"MOST-POSITIVE-SINGLE-FLOAT",			"MOST-POSITIVE-SINGLE-FLOAT [Constant]",
	"MOST-POSITIVE-DOUBLE-FLOAT",			"MOST-POSITIVE-DOUBLE-FLOAT [Constant]",
	"MOST-POSITIVE-LONG-FLOAT",				"MOST-POSITIVE-LONG-FLOAT [Constant]",
	"MULTIPLE-VALUES-LIMIT",				"MULTIPLE-VALUES-LIMIT [Constant]",
	"NIL",									"NIL [Constant]",
	"*PACKAGE*",							"*PACKAGE* [Variable]",
	"PI",									"PI [Constant]",
	"*PRINT-ARRAY*",						"*PRINT-ARRAY* [Variable]",
	"*PRINT-BASE*",							"*PRINT-BASE* [Variable]",
	"*PRINT-CASE*",							"*PRINT-CASE* [Variable]",
	"*PRINT-CIRCLE*",						"*PRINT-CIRCLE* [Variable]",
	"*PRINT-ESCAPE*",						"*PRINT-ESCAPE* [Variable]",
	"*PRINT-GENSYM*",						"*PRINT-GENSYM* [Variable]",
	"*PRINT-LENGTH*",						"*PRINT-LENGTH* [Variable]",
	"*PRINT-LEVEL*",						"*PRINT-LEVEL* [Variable]",
	"*PRINT-LINES*",						"*PRINT-LINES* [Variable]",
	"*PRINT-MISER-WIDTH*",					"*PRINT-MISER-WIDTH* [Variable]",
	"*PRINT-PPRINT-DISPATCH*",				"*PRINT-PPRINT-DISPATCH* [Variable]",
	"*PRINT-PRETTY*",						"*PRINT-PRETTY* [Variable]",
	"*PRINT-RADIX*",						"*PRINT-RADIX* [Variable]",
	"*PRINT-READABLY*",						"*PRINT-READABLY* [Variable]",
	"*PRINT-RIGHT-MARGIN*",					"*PRINT-RIGHT-MARGIN* [Variable]",
	"*QUERY-IO*",							"*QUERY-IO* [Variable]",
	"*RANDOM-STATE*",						"*RANDOM-STATE* [Variable]",
	"*READ-BASE*",							"*READ-BASE* [Variable]",
	"*READ-DEFAULT-FLOAT-FORMAT*",			"*READ-DEFAULT-FLOAT-FORMAT* [Variable]",
	"*READ-EVAL*",							"*READ-EVAL* [Variable]",
	"*READ-SUPPRESS*",						"*READ-SUPPRESS* [Variable]",
	"*READTABLE*",							"*READTABLE* [Variable]",
	"*STANDARD-INPUT*",						"*STANDARD-INPUT* [Variable]",
	"*STANDARD-OUTPUT*",					"*STANDARD-OUTPUT* [Variable]",
	"T",									"T [Constant]",
	"*TERMINAL-IO*",						"*TERMINAL-IO* [Variable]",
	"*TRACE-OUTPUT*",						"*TRACE-OUTPUT* [Variable]",
	
	// Toplevel variables
//	"*",									"* [Variable]",
	"**",									"** [Variable]",
	"***",									"*** [Variable]",
//	"+",									"+ [Variable]",
	"++",									"++ [Variable]",
	"+++",									"+++ [Variable]",
//	"-",									"- [Variable]",
//	"/",									"/ [Variable]",
	"//",									"// [Variable]",
	"///",									"/// [Variable]",
};

int numLambdaLists = sizeof(lambdaLists) / sizeof(LambdaListString);

static int lambdaCompare(const void *elem1, const void *elem2)
{
	return _stricmp(((LambdaListString*)elem1)->symbol, ((LambdaListString*)elem2)->symbol);
}

void sortLambdaLists()
{
	qsort(lambdaLists, numLambdaLists, sizeof(LambdaListString), lambdaCompare);
}

static int lambdaKeyCompare(const void *key, const void *elem2)
{
	return _stricmp((const char*)key, ((LambdaListString*)elem2)->symbol);
}

const char* findLambdaList(const char* symbol)
{
	LambdaListString* result =
		(LambdaListString*)bsearch(symbol, lambdaLists, numLambdaLists, 
				sizeof(LambdaListString), lambdaKeyCompare);
	if (result)
		return ((LambdaListString*)result)->lambdaList;
	else
		return 0;
}
